home *** CD-ROM | disk | FTP | other *** search
/ Champak 52 / Volume 52 - JOGO DISK .iso / Games / scoobysnackmachine.swf / scripts / DefineSprite_1043 / frame_1 / DoAction.as
Text File  |  2007-10-01  |  85KB  |  1,148 lines

  1. var ┬º\x01┬º = 805;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") != 805)
  6.    {
  7.       if(eval("\x01") != 14)
  8.       {
  9.          if(eval("\x01") != 504)
  10.          {
  11.             if(eval("\x01") == 162)
  12.             {
  13.                set("\x01",eval("\x01") + 407);
  14.                Level.__get__Instance().doCreateDoorSwitch(this);
  15.                break;
  16.             }
  17.             if(eval("\x01") == 935)
  18.             {
  19.                set("\x01",eval("\x01") + 23);
  20.                ┬º┬ºpush(mbchr(┬º┬ºpop()));
  21.                loop1:
  22.                while(true)
  23.                {
  24.                   set(┬º┬ºpop(),┬º┬ºpop() - 67);
  25.                   while(true)
  26.                   {
  27.                      if(eval("\x01") != 844)
  28.                      {
  29.                         if(eval("\x01") != 538)
  30.                         {
  31.                            if(eval("\x01") != 948)
  32.                            {
  33.                               if(eval("\x01") == 415)
  34.                               {
  35.                                  set("\x01",eval("\x01") + 51);
  36.                                  loop3:
  37.                                  while(true)
  38.                                  {
  39.                                     set(┬º┬ºpop(),eval("\x01") - 240);
  40.                                     if(┬º┬ºpop())
  41.                                     {
  42.                                        set("\x01",eval("\x01") - 248);
  43.                                     }
  44.                                     while(true)
  45.                                     {
  46.                                        if(eval("\x01") == 891)
  47.                                        {
  48.                                           set("\x01",eval("\x01") - 810);
  49.                                           ┬º┬ºpush(true);
  50.                                        }
  51.                                        else if(eval("\x01") == 195)
  52.                                        {
  53.                                           set("\x01",eval("\x01") + 756);
  54.                                        }
  55.                                        else
  56.                                        {
  57.                                           if(eval("\x01") == 999)
  58.                                           {
  59.                                              break;
  60.                                           }
  61.                                           if(eval("\x01") == 165)
  62.                                           {
  63.                                              set("\x01",eval("\x01") + 133);
  64.                                              eval("∩┐╜∩┐╜∩┐╜∩┐╜")["H\x1f"]()[┬º┬ºconstant(6)](eval("∩┐╜Gb)Gz∩┐╜"),eval("∩┐╜G∩┐╜Q∩┐╜")["∩┐╜∩┐╜"],eval("∩┐╜G∩┐╜Q∩┐╜")["∩┐╜∩┐╜∩┐╜<?∩┐╜I∩┐╜"]);
  65.                                              break loop0;
  66.                                           }
  67.                                           if(eval("\x01") == 59)
  68.                                           {
  69.                                              set("\x01",eval("\x01") + 655);
  70.                                           }
  71.                                           else if(eval("\x01") == 935)
  72.                                           {
  73.                                              set("\x01",eval("\x01") - 158);
  74.                                              if(┬º┬ºpop())
  75.                                              {
  76.                                                 set("\x01",eval("\x01") + 207);
  77.                                              }
  78.                                           }
  79.                                           else if(eval("\x01") == 564)
  80.                                           {
  81.                                              set("\x01",eval("\x01") + 206);
  82.                                           }
  83.                                           else
  84.                                           {
  85.                                              if(eval("\x01") == 627)
  86.                                              {
  87.                                                 set("\x01",eval("\x01") - 432);
  88.                                                 break loop0;
  89.                                              }
  90.                                              if(eval("\x01") == 932)
  91.                                              {
  92.                                                 set("\x01",eval("\x01") + 19);
  93.                                              }
  94.                                              else if(eval("\x01") == 757)
  95.                                              {
  96.                                                 set("\x01",eval("\x01") - 245);
  97.                                                 if(┬º┬ºpop())
  98.                                                 {
  99.                                                    set("\x01",eval("\x01") - 453);
  100.                                                 }
  101.                                              }
  102.                                              else if(eval("\x01") == 729)
  103.                                              {
  104.                                                 set("\x01",eval("\x01") - 102);
  105.                                                 if(┬º┬ºpop())
  106.                                                 {
  107.                                                    set("\x01",eval("\x01") - 432);
  108.                                                 }
  109.                                              }
  110.                                              else if(eval("\x01") == 943)
  111.                                              {
  112.                                                 set("\x01",eval("\x01") - 490);
  113.                                                 ┬º┬ºpush(true);
  114.                                              }
  115.                                              else
  116.                                              {
  117.                                                 if(eval("\x01") == 512)
  118.                                                 {
  119.                                                    set("\x01",eval("\x01") - 453);
  120.                                                    break loop0;
  121.                                                 }
  122.                                                 if(eval("\x01") == 303)
  123.                                                 {
  124.                                                    set("\x01",eval("\x01") - 275);
  125.                                                 }
  126.                                                 else if(eval("\x01") == 477)
  127.                                                 {
  128.                                                    set("\x01",eval("\x01") + 293);
  129.                                                 }
  130.                                                 else if(eval("\x01") == 925)
  131.                                                 {
  132.                                                    set("\x01",eval("\x01") + 74);
  133.                                                    ┬º┬ºpush(true);
  134.                                                 }
  135.                                                 else if(eval("\x01") == 28)
  136.                                                 {
  137.                                                    set("\x01",eval("\x01") + 729);
  138.                                                    ┬º┬ºpush(true);
  139.                                                 }
  140.                                                 else if(eval("\x01") == 951)
  141.                                                 {
  142.                                                    set("\x01",eval("\x01") - 786);
  143.                                                 }
  144.                                                 else if(eval("\x01") == 630)
  145.                                                 {
  146.                                                    set("\x01",eval("\x01") - 258);
  147.                                                    if(┬º┬ºpop())
  148.                                                    {
  149.                                                       set("\x01",eval("\x01") + 192);
  150.                                                    }
  151.                                                 }
  152.                                                 else if(eval("\x01") == 734)
  153.                                                 {
  154.                                                    set("\x01",eval("\x01") + 72);
  155.                                                 }
  156.                                                 else if(eval("\x01") == 511)
  157.                                                 {
  158.                                                    set("\x01",eval("\x01") - 483);
  159.                                                 }
  160.                                                 else if(eval("\x01") == 1000)
  161.                                                 {
  162.                                                    set("\x01",eval("\x01") - 286);
  163.                                                 }
  164.                                                 else
  165.                                                 {
  166.                                                    if(eval("\x01") == 298)
  167.                                                    {
  168.                                                       set("\x01",eval("\x01") - 298);
  169.                                                       break loop0;
  170.                                                    }
  171.                                                    if(eval("\x01") == 714)
  172.                                                    {
  173.                                                       set("\x01",eval("\x01") - 84);
  174.                                                       ┬º┬ºpush(true);
  175.                                                    }
  176.                                                    else
  177.                                                    {
  178.                                                       if(eval("\x01") == 759)
  179.                                                       {
  180.                                                          set("\x01",eval("\x01") - 248);
  181.                                                          loop5:
  182.                                                          while(true)
  183.                                                          {
  184.                                                             while(true)
  185.                                                             {
  186.                                                                if(eval("\x01") == 958)
  187.                                                                {
  188.                                                                   set("\x01",eval("\x01") - 915);
  189.                                                                   ┬º┬ºpush(true);
  190.                                                                   continue;
  191.                                                                }
  192.                                                                if(eval("\x01") == 558)
  193.                                                                {
  194.                                                                   set("\x01",eval("\x01") + 380);
  195.                                                                   continue;
  196.                                                                }
  197.                                                                if(eval("\x01") == 244)
  198.                                                                {
  199.                                                                   set("\x01",eval("\x01") + 210);
  200.                                                                   continue;
  201.                                                                }
  202.                                                                if(eval("\x01") == 686)
  203.                                                                {
  204.                                                                   break loop5;
  205.                                                                }
  206.                                                                if(eval("\x01") == 43)
  207.                                                                {
  208.                                                                   set("\x01",eval("\x01") + 908);
  209.                                                                   if(┬º┬ºpop())
  210.                                                                   {
  211.                                                                      set("\x01",eval("\x01") - 695);
  212.                                                                   }
  213.                                                                   continue;
  214.                                                                }
  215.                                                                if(eval("\x01") == 595)
  216.                                                                {
  217.                                                                   set("\x01",eval("\x01") + 389);
  218.                                                                   if(┬º┬ºpop())
  219.                                                                   {
  220.                                                                      set("\x01",eval("\x01") - 489);
  221.                                                                   }
  222.                                                                   continue;
  223.                                                                }
  224.                                                                if(eval("\x01") == 567)
  225.                                                                {
  226.                                                                   set("\x01",eval("\x01") + 28);
  227.                                                                   ┬º┬ºpush(true);
  228.                                                                   continue;
  229.                                                                }
  230.                                                                if(eval("\x01") == 58)
  231.                                                                {
  232.                                                                   set("\x01",eval("\x01") + 147);
  233.                                                                   continue;
  234.                                                                }
  235.                                                                if(eval("\x01") == 670)
  236.                                                                {
  237.                                                                   set("\x01",eval("\x01") - 396);
  238.                                                                   ┬º┬ºpush(true);
  239.                                                                   continue;
  240.                                                                }
  241.                                                                if(eval("\x01") != 951)
  242.                                                                {
  243.                                                                   if(eval("\x01") == 897)
  244.                                                                   {
  245.                                                                      set("\x01",eval("\x01") - 831);
  246.                                                                      break loop0;
  247.                                                                   }
  248.                                                                   if(eval("\x01") == 511)
  249.                                                                   {
  250.                                                                      set("\x01",eval("\x01") + 159);
  251.                                                                   }
  252.                                                                   else if(eval("\x01") == 832)
  253.                                                                   {
  254.                                                                      set("\x01",eval("\x01") - 245);
  255.                                                                      if(┬º┬ºpop())
  256.                                                                      {
  257.                                                                         set("\x01",eval("\x01") - 483);
  258.                                                                      }
  259.                                                                   }
  260.                                                                   else if(eval("\x01") == 66)
  261.                                                                   {
  262.                                                                      set("\x01",eval("\x01") + 280);
  263.                                                                   }
  264.                                                                   else if(eval("\x01") == 637)
  265.                                                                   {
  266.                                                                      set("\x01",eval("\x01") + 33);
  267.                                                                   }
  268.                                                                   else if(eval("\x01") == 394)
  269.                                                                   {
  270.                                                                      set("\x01",eval("\x01") + 292);
  271.                                                                      if(┬º┬ºpop())
  272.                                                                      {
  273.                                                                         set("\x01",eval("\x01") - 659);
  274.                                                                      }
  275.                                                                   }
  276.                                                                   else
  277.                                                                   {
  278.                                                                      if(eval("\x01") == 882)
  279.                                                                      {
  280.                                                                         set("\x01",eval("\x01") - 323);
  281.                                                                         break loop0;
  282.                                                                      }
  283.                                                                      if(eval("\x01") == 537)
  284.                                                                      {
  285.                                                                         set("\x01",eval("\x01") - 143);
  286.                                                                         ┬º┬ºpush(true);
  287.                                                                      }
  288.                                                                      else if(eval("\x01") == 454)
  289.                                                                      {
  290.                                                                         set("\x01",eval("\x01") + 378);
  291.                                                                         ┬º┬ºpush(true);
  292.                                                                      }
  293.                                                                      else if(eval("\x01") == 256)
  294.                                                                      {
  295.                                                                         set("\x01",eval("\x01") + 682);
  296.                                                                      }
  297.                                                                      else if(eval("\x01") == 27)
  298.                                                                      {
  299.                                                                         set("\x01",eval("\x01") + 540);
  300.                                                                      }
  301.                                                                      else
  302.                                                                      {
  303.                                                                         if(eval("\x01") == 849)
  304.                                                                         {
  305.                                                                            set("\x01",eval("\x01") - 212);
  306.                                                                            ┬º┬ºpush(getTimer());
  307.                                                                            break loop0;
  308.                                                                         }
  309.                                                                         if(eval("\x01") == 205)
  310.                                                                         {
  311.                                                                            set("\x01",eval("\x01") - 59);
  312.                                                                            ┬º┬ºpush(true);
  313.                                                                         }
  314.                                                                         else if(eval("\x01") == 938)
  315.                                                                         {
  316.                                                                            set("\x01",eval("\x01") - 463);
  317.                                                                            ┬º┬ºpush(true);
  318.                                                                         }
  319.                                                                         else if(eval("\x01") == 104)
  320.                                                                         {
  321.                                                                            set("\x01",eval("\x01") + 433);
  322.                                                                         }
  323.                                                                         else if(eval("\x01") == 684)
  324.                                                                         {
  325.                                                                            set("\x01",eval("\x01") - 117);
  326.                                                                         }
  327.                                                                         else if(eval("\x01") == 612)
  328.                                                                         {
  329.                                                                            set("\x01",eval("\x01") - 266);
  330.                                                                         }
  331.                                                                         else
  332.                                                                         {
  333.                                                                            if(eval("\x01") == 984)
  334.                                                                            {
  335.                                                                               set("\x01",eval("\x01") - 489);
  336.                                                                               ┬º┬ºpush(┬º┬ºpop() == ┬º┬ºpop() < (┬º┬ºpop() gt ┬º┬ºpop()));
  337.                                                                               break loop0;
  338.                                                                            }
  339.                                                                            if(eval("\x01") == 559)
  340.                                                                            {
  341.                                                                               set("\x01",eval("\x01") - 182);
  342.                                                                            }
  343.                                                                            else if(eval("\x01") == 521)
  344.                                                                            {
  345.                                                                               set("\x01",eval("\x01") - 144);
  346.                                                                            }
  347.                                                                            else if(eval("\x01") == 812)
  348.                                                                            {
  349.                                                                               set("\x01",eval("\x01") - 358);
  350.                                                                            }
  351.                                                                            else if(eval("\x01") == 377)
  352.                                                                            {
  353.                                                                               set("\x01",eval("\x01") + 292);
  354.                                                                               ┬º┬ºpush(true);
  355.                                                                            }
  356.                                                                            else if(eval("\x01") == 475)
  357.                                                                            {
  358.                                                                               set("\x01",eval("\x01") + 407);
  359.                                                                               if(┬º┬ºpop())
  360.                                                                               {
  361.                                                                                  set("\x01",eval("\x01") - 323);
  362.                                                                               }
  363.                                                                            }
  364.                                                                            else
  365.                                                                            {
  366.                                                                               if(eval("\x01") == 126)
  367.                                                                               {
  368.                                                                                  set("\x01",eval("\x01") + 520);
  369.                                                                                  eval(┬º┬ºconstant(4))[┬º┬ºconstant(5)]()[┬º┬ºconstant(6)](eval("=\x15G∩┐╜"),eval("∩┐╜∩┐╜")["_z∩┐╜\x0fO)#∩┐╜"],eval("∩┐╜∩┐╜")["╥ë∩┐╜\x0b∩┐╜\x17a"]);
  370.                                                                                  break loop0;
  371.                                                                               }
  372.                                                                               if(eval("\x01") == 587)
  373.                                                                               {
  374.                                                                                  set("\x01",eval("\x01") - 483);
  375.                                                                                  ┬º┬ºpush([]);
  376.                                                                                  break loop0;
  377.                                                                               }
  378.                                                                               if(eval("\x01") == 274)
  379.                                                                               {
  380.                                                                                  set("\x01",eval("\x01") + 623);
  381.                                                                                  if(┬º┬ºpop())
  382.                                                                                  {
  383.                                                                                     set("\x01",eval("\x01") - 831);
  384.                                                                                  }
  385.                                                                               }
  386.                                                                               else
  387.                                                                               {
  388.                                                                                  if(eval("\x01") == 613)
  389.                                                                                  {
  390.                                                                                     set("\x01",eval("\x01") - 555);
  391.                                                                                     stopAllSounds();
  392.                                                                                     ┬º┬ºpop();
  393.                                                                                     break loop0;
  394.                                                                                  }
  395.                                                                                  if(eval("\x01") == 146)
  396.                                                                                  {
  397.                                                                                     set("\x01",eval("\x01") + 703);
  398.                                                                                     if(┬º┬ºpop())
  399.                                                                                     {
  400.                                                                                        set("\x01",eval("\x01") - 212);
  401.                                                                                     }
  402.                                                                                  }
  403.                                                                                  else if(eval("\x01") == 217)
  404.                                                                                  {
  405.                                                                                     set("\x01",eval("\x01") - 91);
  406.                                                                                  }
  407.                                                                                  else
  408.                                                                                  {
  409.                                                                                     if(eval("\x01") == 629)
  410.                                                                                     {
  411.                                                                                        break;
  412.                                                                                     }
  413.                                                                                     if(eval("\x01") == 697)
  414.                                                                                     {
  415.                                                                                        set("\x01",eval("\x01") - 160);
  416.                                                                                     }
  417.                                                                                     else if(eval("\x01") == 669)
  418.                                                                                     {
  419.                                                                                        set("\x01",eval("\x01") - 56);
  420.                                                                                        if(┬º┬ºpop())
  421.                                                                                        {
  422.                                                                                           set("\x01",eval("\x01") - 555);
  423.                                                                                        }
  424.                                                                                     }
  425.                                                                                     else if(eval("\x01") == 705)
  426.                                                                                     {
  427.                                                                                        set("\x01",eval("\x01") - 500);
  428.                                                                                     }
  429.                                                                                     else if(eval("\x01") == 346)
  430.                                                                                     {
  431.                                                                                        set("\x01",eval("\x01") + 355);
  432.                                                                                        ┬º┬ºpush(true);
  433.                                                                                     }
  434.                                                                                     else
  435.                                                                                     {
  436.                                                                                        if(eval("\x01") == 459)
  437.                                                                                        {
  438.                                                                                           set("\x01",eval("\x01") - 215);
  439.                                                                                           break loop0;
  440.                                                                                        }
  441.                                                                                        if(eval("\x01") == 701)
  442.                                                                                        {
  443.                                                                                           set("\x01",eval("\x01") - 242);
  444.                                                                                           if(┬º┬ºpop())
  445.                                                                                           {
  446.                                                                                              set("\x01",eval("\x01") - 215);
  447.                                                                                           }
  448.                                                                                        }
  449.                                                                                        else
  450.                                                                                        {
  451.                                                                                           if(eval("\x01") == 646)
  452.                                                                                           {
  453.                                                                                              set("\x01",eval("\x01") - 646);
  454.                                                                                              break loop0;
  455.                                                                                           }
  456.                                                                                           if(eval("\x01") != 495)
  457.                                                                                           {
  458.                                                                                              break loop0;
  459.                                                                                           }
  460.                                                                                           set("\x01",eval("\x01") - 278);
  461.                                                                                        }
  462.                                                                                     }
  463.                                                                                  }
  464.                                                                               }
  465.                                                                            }
  466.                                                                         }
  467.                                                                      }
  468.                                                                   }
  469.                                                                   continue;
  470.                                                                }
  471.                                                                set("\x01",eval("\x01") - 695);
  472.                                                                stop();
  473.                                                                while(true)
  474.                                                                {
  475.                                                                   if(┬º┬ºpop())
  476.                                                                   {
  477.                                                                      set("\x01",eval("\x01") - 730);
  478.                                                                   }
  479.                                                                   else if(eval("\x01") == 428)
  480.                                                                   {
  481.                                                                      set("\x01",eval("\x01") - 168);
  482.                                                                   }
  483.                                                                   else if(eval("\x01") == 260)
  484.                                                                   {
  485.                                                                      set("\x01",eval("\x01") - 204);
  486.                                                                      ┬º┬ºpush(true);
  487.                                                                   }
  488.                                                                   else if(eval("\x01") == 863)
  489.                                                                   {
  490.                                                                      set("\x01",eval("\x01") - 603);
  491.                                                                   }
  492.                                                                   else if(eval("\x01") == 396)
  493.                                                                   {
  494.                                                                      set("\x01",eval("\x01") + 34);
  495.                                                                   }
  496.                                                                   else if(eval("\x01") == 663)
  497.                                                                   {
  498.                                                                      set("\x01",eval("\x01") - 353);
  499.                                                                   }
  500.                                                                   else if(eval("\x01") == 1)
  501.                                                                   {
  502.                                                                      set("\x01",eval("\x01") + 748);
  503.                                                                   }
  504.                                                                   else if(eval("\x01") == 59)
  505.                                                                   {
  506.                                                                      set("\x01",eval("\x01") + 922);
  507.                                                                      if(┬º┬ºpop())
  508.                                                                      {
  509.                                                                         set("\x01",eval("\x01") - 866);
  510.                                                                      }
  511.                                                                   }
  512.                                                                   else if(eval("\x01") == 120)
  513.                                                                   {
  514.                                                                      set("\x01",eval("\x01") + 426);
  515.                                                                      ┬º┬ºpush(true);
  516.                                                                   }
  517.                                                                   else if(eval("\x01") == 374)
  518.                                                                   {
  519.                                                                      set("\x01",eval("\x01") - 254);
  520.                                                                   }
  521.                                                                   else if(eval("\x01") == 20)
  522.                                                                   {
  523.                                                                      set("\x01",eval("\x01") + 563);
  524.                                                                      ┬º┬ºpush(true);
  525.                                                                   }
  526.                                                                   else if(eval("\x01") == 914)
  527.                                                                   {
  528.                                                                      set("\x01",eval("\x01") - 344);
  529.                                                                      if(┬º┬ºpop())
  530.                                                                      {
  531.                                                                         set("\x01",eval("\x01") - 142);
  532.                                                                      }
  533.                                                                   }
  534.                                                                   else if(eval("\x01") == 500)
  535.                                                                   {
  536.                                                                      set("\x01",eval("\x01") - 35);
  537.                                                                      ┬º┬ºpush(true);
  538.                                                                   }
  539.                                                                   else
  540.                                                                   {
  541.                                                                      if(eval("\x01") == 32)
  542.                                                                      {
  543.                                                                         set("\x01",eval("\x01") + 631);
  544.                                                                         break loop0;
  545.                                                                      }
  546.                                                                      if(eval("\x01") == 610)
  547.                                                                      {
  548.                                                                         set("\x01",eval("\x01") - 180);
  549.                                                                      }
  550.                                                                      else
  551.                                                                      {
  552.                                                                         if(eval("\x01") == 430)
  553.                                                                         {
  554.                                                                            set("\x01",eval("\x01") - 265);
  555.                                                                            mcSnack._visible = false;
  556.                                                                            break loop0;
  557.                                                                         }
  558.                                                                         if(eval("\x01") == 944)
  559.                                                                         {
  560.                                                                            set("\x01",eval("\x01") - 55);
  561.                                                                         }
  562.                                                                         else
  563.                                                                         {
  564.                                                                            if(eval("\x01") == 647)
  565.                                                                            {
  566.                                                                               set("\x01",eval("\x01") - 646);
  567.                                                                               break loop0;
  568.                                                                            }
  569.                                                                            if(eval("\x01") == 682)
  570.                                                                            {
  571.                                                                               set("\x01",eval("\x01") - 72);
  572.                                                                               ┬º┬ºpush(delete ┬º┬ºpop()[┬º┬ºpop()]);
  573.                                                                               break loop0;
  574.                                                                            }
  575.                                                                            if(eval("\x01") == 510)
  576.                                                                            {
  577.                                                                               set("\x01",eval("\x01") + 87);
  578.                                                                               if(┬º┬ºpop())
  579.                                                                               {
  580.                                                                                  set("\x01",eval("\x01") + 23);
  581.                                                                               }
  582.                                                                            }
  583.                                                                            else if(eval("\x01") == 433)
  584.                                                                            {
  585.                                                                               set("\x01",eval("\x01") - 313);
  586.                                                                            }
  587.                                                                            else if(eval("\x01") == 749)
  588.                                                                            {
  589.                                                                               set("\x01",eval("\x01") - 134);
  590.                                                                               ┬º┬ºpush(true);
  591.                                                                            }
  592.                                                                            else
  593.                                                                            {
  594.                                                                               if(eval("\x01") == 884)
  595.                                                                               {
  596.                                                                                  set("\x01",eval("\x01") - 451);
  597.                                                                                  stopAllSounds();
  598.                                                                                  break loop0;
  599.                                                                               }
  600.                                                                               if(eval("\x01") == 56)
  601.                                                                               {
  602.                                                                                  set("\x01",eval("\x01") + 828);
  603.                                                                                  if(┬º┬ºpop())
  604.                                                                                  {
  605.                                                                                     set("\x01",eval("\x01") - 451);
  606.                                                                                  }
  607.                                                                               }
  608.                                                                               else if(eval("\x01") == 115)
  609.                                                                               {
  610.                                                                                  set("\x01",eval("\x01") + 385);
  611.                                                                               }
  612.                                                                               else if(eval("\x01") == 532)
  613.                                                                               {
  614.                                                                                  set("\x01",eval("\x01") + 110);
  615.                                                                               }
  616.                                                                               else if(eval("\x01") == 387)
  617.                                                                               {
  618.                                                                                  set("\x01",eval("\x01") + 260);
  619.                                                                                  if(┬º┬ºpop())
  620.                                                                                  {
  621.                                                                                     set("\x01",eval("\x01") - 646);
  622.                                                                                  }
  623.                                                                               }
  624.                                                                               else if(eval("\x01") == 310)
  625.                                                                               {
  626.                                                                                  set("\x01",eval("\x01") + 604);
  627.                                                                                  ┬º┬ºpush(true);
  628.                                                                               }
  629.                                                                               else if(eval("\x01") == 889)
  630.                                                                               {
  631.                                                                                  set("\x01",eval("\x01") - 830);
  632.                                                                                  ┬º┬ºpush(true);
  633.                                                                               }
  634.                                                                               else
  635.                                                                               {
  636.                                                                                  if(eval("\x01") == 570)
  637.                                                                                  {
  638.                                                                                     set("\x01",eval("\x01") - 142);
  639.                                                                                     break loop0;
  640.                                                                                  }
  641.                                                                                  if(eval("\x01") == 615)
  642.                                                                                  {
  643.                                                                                     set("\x01",eval("\x01") - 282);
  644.                                                                                     if(┬º┬ºpop())
  645.                                                                                     {
  646.                                                                                        set("\x01",eval("\x01") + 611);
  647.                                                                                     }
  648.                                                                                  }
  649.                                                                                  else
  650.                                                                                  {
  651.                                                                                     if(eval("\x01") == 981)
  652.                                                                                     {
  653.                                                                                        set("\x01",eval("\x01") - 866);
  654.                                                                                        break loop0;
  655.                                                                                     }
  656.                                                                                     if(eval("\x01") == 165)
  657.                                                                                     {
  658.                                                                                        set("\x01",eval("\x01") - 165);
  659.                                                                                        break loop0;
  660.                                                                                     }
  661.                                                                                     if(eval("\x01") == 645)
  662.                                                                                     {
  663.                                                                                        set("\x01",eval("\x01") + 297);
  664.                                                                                     }
  665.                                                                                     else if(eval("\x01") == 425)
  666.                                                                                     {
  667.                                                                                        set("\x01",eval("\x01") + 75);
  668.                                                                                     }
  669.                                                                                     else if(eval("\x01") == 400)
  670.                                                                                     {
  671.                                                                                        set("\x01",eval("\x01") + 242);
  672.                                                                                     }
  673.                                                                                     else if(eval("\x01") == 465)
  674.                                                                                     {
  675.                                                                                        set("\x01",eval("\x01") - 267);
  676.                                                                                        if(┬º┬ºpop())
  677.                                                                                        {
  678.                                                                                           set("\x01",eval("\x01") + 347);
  679.                                                                                        }
  680.                                                                                     }
  681.                                                                                     else if(eval("\x01") == 78)
  682.                                                                                     {
  683.                                                                                        set("\x01",eval("\x01") + 232);
  684.                                                                                     }
  685.                                                                                     else if(eval("\x01") == 583)
  686.                                                                                     {
  687.                                                                                        set("\x01",eval("\x01") - 551);
  688.                                                                                        if(┬º┬ºpop())
  689.                                                                                        {
  690.                                                                                           set("\x01",eval("\x01") + 631);
  691.                                                                                        }
  692.                                                                                     }
  693.                                                                                     else if(eval("\x01") == 739)
  694.                                                                                     {
  695.                                                                                        set("\x01",eval("\x01") + 150);
  696.                                                                                     }
  697.                                                                                     else if(eval("\x01") == 942)
  698.                                                                                     {
  699.                                                                                        set("\x01",eval("\x01") - 432);
  700.                                                                                        ┬º┬ºpush(true);
  701.                                                                                     }
  702.                                                                                     else
  703.                                                                                     {
  704.                                                                                        if(eval("\x01") == 333)
  705.                                                                                        {
  706.                                                                                           set("\x01",eval("\x01") + 611);
  707.                                                                                           break loop0;
  708.                                                                                        }
  709.                                                                                        if(eval("\x01") == 545)
  710.                                                                                        {
  711.                                                                                           set("\x01",eval("\x01") + 397);
  712.                                                                                        }
  713.                                                                                        else if(eval("\x01") == 546)
  714.                                                                                        {
  715.                                                                                           set("\x01",eval("\x01") + 269);
  716.                                                                                           if(┬º┬ºpop())
  717.                                                                                           {
  718.                                                                                              set("\x01",eval("\x01") - 283);
  719.                                                                                           }
  720.                                                                                        }
  721.                                                                                        else if(eval("\x01") == 110)
  722.                                                                                        {
  723.                                                                                           set("\x01",eval("\x01") + 572);
  724.                                                                                           if(┬º┬ºpop())
  725.                                                                                           {
  726.                                                                                              set("\x01",eval("\x01") - 72);
  727.                                                                                           }
  728.                                                                                        }
  729.                                                                                        else if(eval("\x01") == 642)
  730.                                                                                        {
  731.                                                                                           set("\x01",eval("\x01") - 532);
  732.                                                                                           ┬º┬ºpush(true);
  733.                                                                                        }
  734.                                                                                        else
  735.                                                                                        {
  736.                                                                                           if(eval("\x01") == 815)
  737.                                                                                           {
  738.                                                                                              set("\x01",eval("\x01") - 283);
  739.                                                                                              break loop0;
  740.                                                                                           }
  741.                                                                                           if(eval("\x01") == 198)
  742.                                                                                           {
  743.                                                                                              set("\x01",eval("\x01") + 347);
  744.                                                                                              prevFrame();
  745.                                                                                              ┬º┬ºpush(┬º┬ºpop() < ┬º┬ºpop() + ┬º┬ºpop());
  746.                                                                                              break loop0;
  747.                                                                                           }
  748.                                                                                           if(eval("\x01") == 597)
  749.                                                                                           {
  750.                                                                                              set("\x01",eval("\x01") + 23);
  751.                                                                                              break loop0;
  752.                                                                                           }
  753.                                                                                           if(eval("\x01") != 620)
  754.                                                                                           {
  755.                                                                                              break loop0;
  756.                                                                                           }
  757.                                                                                           set("\x01",eval("\x01") - 600);
  758.                                                                                        }
  759.                                                                                     }
  760.                                                                                  }
  761.                                                                               }
  762.                                                                            }
  763.                                                                         }
  764.                                                                      }
  765.                                                                   }
  766.                                                                   while(true)
  767.                                                                   {
  768.                                                                      if(eval("\x01") == 41)
  769.                                                                      {
  770.                                                                         set("\x01",eval("\x01") + 346);
  771.                                                                         ┬º┬ºpush(true);
  772.                                                                      }
  773.                                                                      else
  774.                                                                      {
  775.                                                                         if(eval("\x01") != 289)
  776.                                                                         {
  777.                                                                            break;
  778.                                                                         }
  779.                                                                         set("\x01",eval("\x01") + 460);
  780.                                                                      }
  781.                                                                   }
  782.                                                                }
  783.                                                             }
  784.                                                             set("\x01",eval("\x01") - 412);
  785.                                                          }
  786.                                                          set("\x01",eval("\x01") - 659);
  787.                                                          ┬º┬ºpop() extends ┬º┬ºpop() | ┬º┬ºpop();
  788.                                                          break loop0;
  789.                                                       }
  790.                                                       if(eval("\x01") == 372)
  791.                                                       {
  792.                                                          set("\x01",eval("\x01") + 192);
  793.                                                          ┬º┬ºpush(┬º┬ºpop());
  794.                                                          ┬º┬ºpush(getTimer());
  795.                                                          break loop0;
  796.                                                       }
  797.                                                       if(eval("\x01") == 552)
  798.                                                       {
  799.                                                          set("\x01",eval("\x01") + 373);
  800.                                                       }
  801.                                                       else
  802.                                                       {
  803.                                                          if(eval("\x01") == 243)
  804.                                                          {
  805.                                                             break loop3;
  806.                                                          }
  807.                                                          if(eval("\x01") == 770)
  808.                                                          {
  809.                                                             set("\x01",eval("\x01") + 165);
  810.                                                             ┬º┬ºpush(true);
  811.                                                          }
  812.                                                          else
  813.                                                          {
  814.                                                             if(eval("\x01") == 777)
  815.                                                             {
  816.                                                                set("\x01",eval("\x01") + 207);
  817.                                                                ┬º┬ºpop();
  818.                                                                ┬º┬ºpush(┬º┬ºpop() * (┬º┬ºpop() + 1));
  819.                                                                break loop0;
  820.                                                             }
  821.                                                             if(eval("\x01") == 984)
  822.                                                             {
  823.                                                                set("\x01",eval("\x01") - 41);
  824.                                                             }
  825.                                                             else if(eval("\x01") == 806)
  826.                                                             {
  827.                                                                set("\x01",eval("\x01") - 77);
  828.                                                                ┬º┬ºpush(true);
  829.                                                             }
  830.                                                             else if(eval("\x01") == 949)
  831.                                                             {
  832.                                                                set("\x01",eval("\x01") - 24);
  833.                                                             }
  834.                                                             else
  835.                                                             {
  836.                                                                if(eval("\x01") == 297)
  837.                                                                {
  838.                                                                   set("\x01",eval("\x01") + 652);
  839.                                                                   break loop0;
  840.                                                                }
  841.                                                                if(eval("\x01") == 980)
  842.                                                                {
  843.                                                                   set("\x01",eval("\x01") - 174);
  844.                                                                }
  845.                                                                else if(eval("\x01") == 453)
  846.                                                                {
  847.                                                                   set("\x01",eval("\x01") - 210);
  848.                                                                   if(┬º┬ºpop())
  849.                                                                   {
  850.                                                                      set("\x01",eval("\x01") + 737);
  851.                                                                   }
  852.                                                                }
  853.                                                                else if(eval("\x01") == 728)
  854.                                                                {
  855.                                                                   set("\x01",eval("\x01") + 215);
  856.                                                                }
  857.                                                                else
  858.                                                                {
  859.                                                                   if(eval("\x01") != 81)
  860.                                                                   {
  861.                                                                      break loop0;
  862.                                                                   }
  863.                                                                   set("\x01",eval("\x01") + 216);
  864.                                                                   if(┬º┬ºpop())
  865.                                                                   {
  866.                                                                      set("\x01",eval("\x01") + 652);
  867.                                                                   }
  868.                                                                }
  869.                                                             }
  870.                                                          }
  871.                                                       }
  872.                                                    }
  873.                                                 }
  874.                                              }
  875.                                           }
  876.                                        }
  877.                                     }
  878.                                  }
  879.                                  set("\x01",eval("\x01") + 737);
  880.                                  break loop0;
  881.                               }
  882.                               if(eval("\x01") == 241)
  883.                               {
  884.                                  set("\x01",eval("\x01") - 51);
  885.                                  continue;
  886.                                  continue;
  887.                               }
  888.                               if(eval("\x01") == 234)
  889.                               {
  890.                                  set("\x01",eval("\x01") + 134);
  891.                                  if(┬º┬ºpop())
  892.                                  {
  893.                                     set("\x01",eval("\x01") + 551);
  894.                                  }
  895.                                  continue;
  896.                               }
  897.                               if(eval("\x01") != 190)
  898.                               {
  899.                                  if(eval("\x01") == 871)
  900.                                  {
  901.                                     set("\x01",eval("\x01") - 622);
  902.                                     ┬º┬ºpush(getTimer());
  903.                                     break loop0;
  904.                                  }
  905.                                  if(eval("\x01") == 913)
  906.                                  {
  907.                                     set("\x01",eval("\x01") - 364);
  908.                                     continue;
  909.                                     continue;
  910.                                  }
  911.                                  if(eval("\x01") != 289)
  912.                                  {
  913.                                     if(eval("\x01") != 466)
  914.                                     {
  915.                                        if(eval("\x01") == 368)
  916.                                        {
  917.                                           set("\x01",eval("\x01") + 551);
  918.                                           break loop0;
  919.                                        }
  920.                                        if(eval("\x01") == 653)
  921.                                        {
  922.                                           set("\x01",eval("\x01") - 163);
  923.                                           continue;
  924.                                           continue;
  925.                                        }
  926.                                        if(eval("\x01") == 947)
  927.                                        {
  928.                                           set("\x01",eval("\x01") - 712);
  929.                                           if(┬º┬ºpop())
  930.                                           {
  931.                                              set("\x01",eval("\x01") + 418);
  932.                                           }
  933.                                           continue;
  934.                                        }
  935.                                        if(eval("\x01") != 554)
  936.                                        {
  937.                                           if(eval("\x01") == 984)
  938.                                           {
  939.                                              break;
  940.                                           }
  941.                                           if(eval("\x01") == 919)
  942.                                           {
  943.                                              set("\x01",eval("\x01") - 898);
  944.                                              continue;
  945.                                              continue;
  946.                                           }
  947.                                           if(eval("\x01") == 702)
  948.                                           {
  949.                                              set("\x01",eval("\x01") + 215);
  950.                                              continue;
  951.                                           }
  952.                                           if(eval("\x01") != 249)
  953.                                           {
  954.                                              if(eval("\x01") != 509)
  955.                                              {
  956.                                                 if(eval("\x01") == 86)
  957.                                                 {
  958.                                                    set("\x01",eval("\x01") + 898);
  959.                                                    break loop0;
  960.                                                 }
  961.                                                 if(eval("\x01") != 131)
  962.                                                 {
  963.                                                    if(eval("\x01") == 235)
  964.                                                    {
  965.                                                       break loop1;
  966.                                                    }
  967.                                                    if(eval("\x01") == 490)
  968.                                                    {
  969.                                                       set("\x01",eval("\x01") - 44);
  970.                                                       ┬º┬ºpush(true);
  971.                                                       continue;
  972.                                                    }
  973.                                                    if(eval("\x01") == 446)
  974.                                                    {
  975.                                                       set("\x01",eval("\x01") + 119);
  976.                                                       if(┬º┬ºpop())
  977.                                                       {
  978.                                                          set("\x01",eval("\x01") + 341);
  979.                                                       }
  980.                                                       continue;
  981.                                                    }
  982.                                                    if(eval("\x01") == 21)
  983.                                                    {
  984.                                                       set("\x01",eval("\x01") + 488);
  985.                                                       ┬º┬ºpush(true);
  986.                                                       continue;
  987.                                                    }
  988.                                                    if(eval("\x01") == 917)
  989.                                                    {
  990.                                                       set("\x01",eval("\x01") - 149);
  991.                                                       ┬º┬ºpush(true);
  992.                                                       continue;
  993.                                                    }
  994.                                                    if(eval("\x01") == 565)
  995.                                                    {
  996.                                                       set("\x01",eval("\x01") + 341);
  997.                                                       ┬º┬ºpush(mbsubstring(┬º┬ºpop(),┬º┬ºpop(),┬º┬ºpop()));
  998.                                                       break loop0;
  999.                                                    }
  1000.                                                 }
  1001.                                                 set("\x01",eval("\x01") - 110);
  1002.                                                 continue;
  1003.                                                 if(eval("\x01") != 906)
  1004.                                                 {
  1005.                                                    if(eval("\x01") != 768)
  1006.                                                    {
  1007.                                                       if(eval("\x01") == 549)
  1008.                                                       {
  1009.                                                          set("\x01",eval("\x01") - 102);
  1010.                                                          Level.__get__Instance().doCreateCradleRail(this,CradleRail.SIZE_MEDIUM);
  1011.                                                          break loop0;
  1012.                                                       }
  1013.                                                       if(eval("\x01") == 447)
  1014.                                                       {
  1015.                                                          set("\x01",eval("\x01") - 447);
  1016.                                                          break loop0;
  1017.                                                       }
  1018.                                                    }
  1019.                                                    set("\x01",eval("\x01") - 353);
  1020.                                                    if(┬º┬ºpop())
  1021.                                                    {
  1022.                                                       set("\x01",eval("\x01") + 51);
  1023.                                                    }
  1024.                                                 }
  1025.                                              }
  1026.                                              set("\x01",eval("\x01") + 362);
  1027.                                              if(┬º┬ºpop())
  1028.                                              {
  1029.                                                 set("\x01",eval("\x01") - 622);
  1030.                                              }
  1031.                                              continue;
  1032.                                              set("\x01",eval("\x01") - 357);
  1033.                                           }
  1034.                                           set("\x01",eval("\x01") + 289);
  1035.                                        }
  1036.                                        set("\x01",eval("\x01") - 468);
  1037.                                     }
  1038.                                     set("\x01",eval("\x01") - 276);
  1039.                                     continue;
  1040.                                     if(┬º┬ºpop())
  1041.                                     {
  1042.                                        set("\x01",eval("\x01") + 898);
  1043.                                     }
  1044.                                  }
  1045.                                  set("\x01",eval("\x01") + 201);
  1046.                               }
  1047.                               set("\x01",eval("\x01") + 757);
  1048.                            }
  1049.                            set("\x01",eval("\x01") - 410);
  1050.                            continue;
  1051.                            ┬º┬ºpush(true);
  1052.                         }
  1053.                         set("\x01",eval("\x01") + 16);
  1054.                         ┬º┬ºpush(true);
  1055.                         continue;
  1056.                      }
  1057.                      set("\x01",eval("\x01") - 610);
  1058.                      ┬º┬ºpush(true);
  1059.                   }
  1060.                }
  1061.                set("\x01",eval("\x01") + 418);
  1062.                break;
  1063.             }
  1064.             if(eval("\x01") == 497)
  1065.             {
  1066.                set("\x01",eval("\x01") - 483);
  1067.                ┬º┬ºpush(chr(┬º┬ºpop()));
  1068.                break;
  1069.             }
  1070.             if(eval("\x01") != 925)
  1071.             {
  1072.                if(eval("\x01") == 391)
  1073.                {
  1074.                   set("\x01",eval("\x01") + 544);
  1075.                   if(┬º┬ºpop())
  1076.                   {
  1077.                      set("\x01",eval("\x01") + 23);
  1078.                   }
  1079.                   continue;
  1080.                }
  1081.                if(eval("\x01") == 698)
  1082.                {
  1083.                   set("\x01",eval("\x01") + 290);
  1084.                   continue;
  1085.                   continue;
  1086.                }
  1087.                if(eval("\x01") == 312)
  1088.                {
  1089.                   set("\x01",eval("\x01") - 150);
  1090.                   continue;
  1091.                }
  1092.                if(eval("\x01") == 958)
  1093.                {
  1094.                   set("\x01",eval("\x01") - 54);
  1095.                   continue;
  1096.                }
  1097.                if(eval("\x01") == 118)
  1098.                {
  1099.                   set("\x01",eval("\x01") + 786);
  1100.                   continue;
  1101.                }
  1102.                if(eval("\x01") == 904)
  1103.                {
  1104.                   set("\x01",eval("\x01") + 21);
  1105.                   ┬º┬ºpush(true);
  1106.                   continue;
  1107.                }
  1108.             }
  1109.             set("\x01",eval("\x01") - 428);
  1110.             if(┬º┬ºpop())
  1111.             {
  1112.                set("\x01",eval("\x01") - 483);
  1113.             }
  1114.             continue;
  1115.          }
  1116.          set("\x01",eval("\x01") - 342);
  1117.          continue;
  1118.          if(eval("\x01") != 988)
  1119.          {
  1120.             if(eval("\x01") != 869)
  1121.             {
  1122.                if(eval("\x01") == 123)
  1123.                {
  1124.                   set("\x01",eval("\x01") + 189);
  1125.                   break;
  1126.                }
  1127.                if(eval("\x01") == 569)
  1128.                {
  1129.                   set("\x01",eval("\x01") - 569);
  1130.                   break;
  1131.                }
  1132.             }
  1133.             set("\x01",eval("\x01") - 746);
  1134.             if(┬º┬ºpop())
  1135.             {
  1136.                set("\x01",eval("\x01") + 189);
  1137.             }
  1138.          }
  1139.          set("\x01",eval("\x01") - 119);
  1140.       }
  1141.       set("\x01",eval("\x01") + 974);
  1142.       continue;
  1143.       ┬º┬ºpush(true);
  1144.    }
  1145.    set("\x01",eval("\x01") - 414);
  1146.    ┬º┬ºpush(true);
  1147. }
  1148.